home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 41 / Amiga Format CD41 (1999-06)(Future Publishing)(GB)[!][issue 1999-07].iso / -seriously_amiga- / programming / other / gui4cli / ext / gui4cli.h < prev   
C/C++ Source or Header  |  1999-04-29  |  19KB  |  422 lines
  1. /*********************************************************************
  2. **
  3. **    Gui4Cli Include file
  4. **    $VER: 3.6 (20/8/98)
  5. **    Author : D. Keletsekis - dck@hol.gr
  6. **
  7. **    This file holds some of the Gui4Cli internal structures.
  8. **    You can access them by getting a pointer to the GCmain
  9. **    structure (see end of this file) and following the pointers
  10. **    from there.
  11. **
  12. **    The *GCmain pointer is stored in the "gcmain" field of the
  13. **    Gui4Cli message structure, and you can get it by sending 
  14. **    a GM_LOCK message to Gui4Cli, or when Gui4Cli sends you a
  15. **    message (using the CALL command).
  16. **
  17. **    From *GCmain you can see all the gui files, the events,
  18. **    the listviews, the variables, and most of everything that
  19. **    Gui4Cli holds dear. Why you would ever want to, is an 
  20. **    other matter.. Look at the C examples in this directory
  21. **    for information on how to access & manipulate them.
  22. **
  23. *********************************************************************/
  24.  
  25. // union used in events & commands, to hold the arguments, which
  26. // can be numbers or strings - LTWH=numbers, Title=string etc..
  27.  
  28. union commandunion
  29. {  LONG  num;    // if it's a number
  30.    char  *str;   // if it's a string
  31.    APTR  dummy;  // forget it..
  32. };
  33.  
  34. #define OPT_COUNT  12  // max number of arguments 
  35.  
  36. /*********************************************************************
  37.      The Gui4Cli message structure - use it to communicate with G4C
  38. *********************************************************************/
  39.  
  40. struct g4cmsg
  41. {
  42.    struct Message node;    // EXEC message structure
  43.  
  44.    // When Gui4Cli sends the message :
  45.    // - This will be a pointer to the command name which will
  46.    //   have been converted to upper case. If there are any more
  47.    //   arguments passed, then these will be stored in "args[0-5]"
  48.    // When you send a GM_COMMAND or GM_RUN message to Gui4Cli :
  49.    // - This must point to a string buffer which will contain
  50.    //   the command which you want Gui4Cli to execute.
  51.    // otherwise null..
  52.    UBYTE *com;
  53.  
  54.    // This will either contain a pointer to struct *GCmain, or 
  55.    // NULL. You get the pointer when Gui4Cli sends you a
  56.    // message (with the CALL command), or when Gui4Cli replies 
  57.    // to a GM_LOCK message that you sent. Otherwise NULL.
  58.    struct GCmain *gcmain;
  59.  
  60.    // Set this to 392001 which is a "magic" number that Gui4Cli
  61.    // will recognise as being a GC type message.
  62.    LONG  magic;
  63.  
  64.    // 6 argument strings. When Gui4Cli sends you a message, it
  65.    // will consist of a command (which will be in *com above)
  66.    // and up to 6 arguments. This is where the arguments will
  67.    // be stored (if any) - so, if arg[x] is not NULL, it will
  68.    // contain a pointer to a null terminated string.
  69.    UBYTE *args[6];
  70.  
  71.    // if you want to return something, then you must store it
  72.    // in a buffer which you MUST get using AllocVec() and point
  73.    // it here. The buffer will be available from within Gui4Cli
  74.    // as internal variable $$CALL.RET
  75.    // IMPORTANT NOTE:
  76.    // If you attach such a buffer, it will be freed by Gui4Cli, 
  77.    // using FreeVec(), before Gui4Cli sends it's next message.
  78.    UBYTE *msgret;
  79.  
  80.    UBYTE type;        // type of message - see defines below
  81.    LONG  res;        // error status (0 means OK)
  82.    APTR  data;        // null - for future expansion
  83.    APTR  exp;        // null - for future expansion
  84. };
  85.  
  86. /*********************************************************************
  87.      Message types
  88.      These are the currently available types for the "type" field 
  89.      of the above structure.
  90. *********************************************************************/
  91.  
  92. // ------------------------------------------------------------------
  93. // A)  If the command is sent by a program to Gui4Cli:
  94. //   The "com" field must point to a valid command line to be 
  95. //   executed by Gui4Cli - only commands which are defined as 
  96. //   "arexx capable" can be executed. The line will be translated,
  97. //   then parsed and executed. Upon returning, the "res"
  98. //   field will hold the return code, if any was set..
  99. // ---------------------- ...
  100. // B)  If sent by Gui4Cli to an outside program, using CALL :
  101. //   "com" will point to the command name, "gcmain" will contain
  102. //   a pointer to the GCmain structure, and if there are any arguments
  103. //   they will be stored in "args[0]"-"args[5]". Upon return, $$RetCode 
  104. //   will be set to the "res" value you have set (if any). 0 means OK
  105. // ------------------------------------------------------------------
  106. #define GM_COMMAND  1
  107.  
  108. // ------------------------------------------------------------------
  109. // This is the same as GM_COMMAND, Part (A). The difference is that 
  110. // while GM_COMMAND will do the commands synchronously - i.e. the 
  111. // program which sends the command will have to wait until after
  112. // Gui4Cli executes the command to receive the repply, GM_RUN will
  113. // pass the command to Gui4Cli and return and let Gui4Cli get on
  114. // with it asynchronously. The draw back is that you will not know
  115. // when the command finished executing and if it was successful.
  116. // ------------------------------------------------------------------
  117. #define GM_RUN      2
  118.  
  119. // ------------------------------------------------------------------
  120. // GM_LOCK will freeze Gui4Cli, until a GM_UNLOCK message is
  121. // received. When you send a GM_LOCK message, Gui4Cli will immediately
  122. // reply, storing a pointer to the "GCmain" structure in the message's
  123. // "gcmain" field. It will then wait, doing nothing until a GM_UNLOCK
  124. // message is received. Do what you want and then send GM_UNLOCK.
  125. // ------------------------------------------------------------------
  126. #define GM_LOCK        5
  127.  
  128. // ------------------------------------------------------------------
  129. // MUST UNLOCK Gui4Cli after a GM_LOCK message.
  130. // ------------------------------------------------------------------
  131. #define GM_UNLOCK   6
  132.  
  133. /*********************************************************************
  134.     LV helper structures
  135.     these hold various things for listviews..
  136. *********************************************************************/
  137.  
  138. // holds listview colors etc
  139.  
  140. struct styledef
  141. {
  142.    BOOL  usestyle;    // =1 if styles have been specifically set
  143.    WORD  fg;        // foreground pen
  144.    WORD  nbg;           // normal background pen
  145.    WORD  sbg;        // selected background pen
  146.    WORD  shad;        // shadow - signifies to make letters 3D
  147. };
  148.  
  149. // If a LV loads a DataBase file, it allocates a dbdef struct
  150. // and links it to the "db" member of the fulist struct. All
  151. // field definitions are link-listed to this struct.
  152.  
  153. struct lvfield              // field definition struct (AllocVec)
  154. {
  155.    char name[31];         // field name
  156.    LONG start;            // byte in record where field starts
  157.    LONG length;           // field length
  158.    UBYTE type;            // field type (N)umber,(C)har or (D)ate
  159.    struct styledef sd;  // full styledef struct
  160.    struct lvfield *next; // pointer to next field or null
  161.    // ----------- private fields below
  162. };
  163.  
  164. struct dbdef
  165. {
  166.    LONG fieldnum;        // number of fields
  167.    LONG reclength;        // record length
  168.    struct lvfield *topfield;    // linked list of fields (AllocVec)
  169.    // ------------- private fields below
  170. };
  171.  
  172. /*********************************************************************
  173.       LISTVIEW LINE
  174.       Every line of a listview has a structure like this.
  175.       They are kept in a struct List and given to the LV.
  176.       There is a pointer to this list in struct "fulist".
  177.       The LV shows the text pointed to by node->ln_Name.
  178.       This is set to point to some part of the *start buffer,
  179.       according to how much the list is shifted (left/right)
  180. **********************************************************************/
  181.  
  182. struct lister 
  183. { 
  184.   struct Node node;   // a normal exec node for struct List. The ln_Name
  185.                       // field points to the start of the visible text.
  186.   UBYTE *start;       // pointer to the start of the line's text - i.e. the full buffer
  187.   LONG  length;       // line length - buffer is AllocMem (length+1) !!!!
  188.   BOOL Selected;      // 1 = line is selected, 0 = it's not
  189.   struct fulist *fls; // ptr back to parent fulist structure (for hook)
  190.   UBYTE filend;       // pointer to end of filename - for dir listviews
  191.   UBYTE type;         // type of entry - F=file, D=dir etc
  192. };
  193.  
  194.  
  195. /*********************************************************************
  196.       LISTVIEW
  197.       This is the main listview structure holding all the information
  198.       needed for all the various types of listviews. A pointer to
  199.       this struct is kept in the EVENT structure of the xLISTVIEW event
  200. **********************************************************************/
  201.  
  202. struct fulist
  203. {
  204.   struct List *ls;         // the list structure with all the lines
  205.   int    maxlength;        // length of longest line (strlen)
  206.   int    maxnow;           // - not used any more
  207.   LONG   totnum;           // total number of lines
  208.   struct lister *curpt;    // pointer to current record (or null)
  209.   LONG   line;             // line number of current record (-1 if none)
  210.   UBYTE  maxdirlength;     // length of longest dir name (for size alignment)
  211.   char   curdir[140];      // buffer for current dir name (when in DIR mode)  
  212.   int    dirhook;          // gadid of xlvdirhook event or 0
  213.   struct Event *bt;        // point to the xLISTVIEW event
  214.   struct guifile *gf;      // points back to parent gui file
  215.   LONG   magic;            // sanity check - set to 22108
  216.   struct dbdef *db;       // link field info structure for database LVs 
  217.   struct styledef nsd;     // full styledef struct for normal records
  218.   struct styledef dsd;     // full styledef struct for dir,vol etc
  219.   SHORT  linedist;       // distance between lines
  220.  
  221.   // ----------- private fields below..
  222. };
  223.  
  224. /********************************************************************
  225.      IMAGES
  226.      structure used to hold image information
  227. *********************************************************************/
  228. struct imginfo 
  229. {  
  230.    Object                *po;      // the datatype object
  231.    struct BitMapHeader   *bmh;     // the header..
  232.    struct BitMap         *bm;      // the data..
  233.    char                  name[35]; // the name (alias) of this image
  234.    LONG                  count;    // times in use
  235.    struct imginfo        *next;    // next image
  236. };
  237.  
  238. /*********************************************************************
  239.       VARIABLE
  240.       This is the variables structure. Variables are kept in linked
  241.       list - Each gui file has a pointer to such a list for its own
  242.       private vars. the Global vars pointer is kept in the GCmain struct.
  243. **********************************************************************/
  244.  
  245. struct var
  246. { 
  247.    char *name;          // the variable's name (AllocVec)
  248.    char *str;           // the variable's contents (AllocVec)
  249.    struct var *next;    // ptr to next variable in list
  250.    APTR ex;        // for future expansion (NULL now)
  251. };
  252.  
  253. /*********************************************************************
  254.       CYCLER & RADIO GADGETS
  255.       This structure holds the fields of a cycler or a radio button
  256.       gadget. A pointer to it is kept from the event structure. 
  257. **********************************************************************/
  258.  
  259. struct cycler
  260. { 
  261.   char *cyp[13];   // Pointers to cycler/radio strings
  262.   char *var[13];   // Pointers to value to put in $variable
  263.   int  cno;        // Number of strings actually declared (12 max)
  264.   int  height;     // distance between radio buttons (N/A for cyclers)
  265. }; 
  266.  
  267. /*********************************************************************
  268.       EVENT COMMAND
  269.       This structure holds an event command. They are linked in
  270.       a list with a pointer to the top event command kept in the
  271.       event structure.
  272. **********************************************************************/
  273.  
  274. struct line
  275. {
  276.   SHORT  type;                         // type of command (see Gui4Cli.def)
  277.   int    progline;                     // line No of the command in the file
  278.   union  commandunion arg[OPT_COUNT];  // the command's arguments
  279.   struct line *next;                   // pointer to next command or NULL
  280.   // -------- private fields below
  281. };
  282.  
  283. /*********************************************************************
  284.       EVENT
  285.       This is the main event structure. Events are linked in a list
  286.       with a pointer to the top event kept in the guifile structure.
  287. **********************************************************************/
  288.  
  289. struct Event
  290. {
  291.   union commandunion arg[OPT_COUNT];    // the event's arguments (LTWH etc)
  292.   int ID;                // gadget's internal id - only for Gui4Cli
  293.   int UID;               // GADID of gadget (or 0 if not defined)
  294.   int key;               // Decimal value of Keyboard shortcut
  295.   LONG  val;             // current value of gadget (varies..)
  296.   SHORT type;            // type of gadget (see file Gui4Cli.def)
  297.   char  *file;           // pointer to the event's variable name
  298.   BOOL  onoff;           // 0=gadget is ON, 1=OFF
  299.   LONG progline;         // Line in the file where event is declared
  300.   LONG lastline;         // Line No of last of this events commands
  301.   BOOL  appear;          // whether it appears or not (SHOW|HIDE)
  302.   int   l, t, w, h;      // current ACTUAL (full window) left top width height
  303.   struct guifile *gf;    // pointer to the guifile of this event
  304.   struct Gadget *gad;       // Pointer to the gadget struct - If it's a gadget
  305.   struct DiskObject *dobj;  // Pointer to icon for AppIcons & icons
  306.   struct cycler *cy;        // pointer to cycler struct - also cast into general purpose pointers
  307.   struct fulist *lt;     // pointer to struct if it's a ListView (or NULL)
  308.   struct TextAttr *fta;  // text attribute struct
  309.   struct TextFont *ftf;  // text font struct
  310.   UBYTE  *help;          // pointer to help text or NULL
  311.   struct line *topx;     // first of a linked list of event commands
  312.   struct var *topvar;    // first of list of this event's variables (if defined)
  313.   struct Event *next;   // next in the list of events
  314.   // --------- private fields below here
  315. };
  316.  
  317.  
  318. /*********************************************************************
  319.       GUI FILE
  320.       This is the main guifile structure. Guis are linked in a list
  321.       with a pointer to the first gui kept in the G4C structure.
  322. **********************************************************************/
  323.  
  324. struct guifile
  325. { 
  326.   LONG   magic;                 // for sanity checks - must be 7225825
  327.   struct Window   *wn;          // pointer to this gui's window (if open)
  328.   struct Screen   *sc;          // ptr to screen (if window's open)
  329.   struct AppMenuItem *appitem;  // ptr to appitem (if any)
  330.   struct Menu *menu;            // menus (if any)
  331.   struct TextAttr *fta;         // text attributes
  332.   struct TextFont *ftf;         // text font
  333.   BPTR cp;                      // console pointer for this gui (if any)
  334.   char scr[31];                 // buffer for screen name
  335.   char imgname[35];             // name of background image (if any)
  336.   char *wntitle;                // ptr to window's title
  337.   char *wow;                    // pointer to win-on-win gui name
  338.   int  wowl, wowt;              // offsets for winonwin
  339.   char fullpath[140];           // full path & filename of gui file
  340.   char name[35];                // just the filename (separate for guirename)
  341.   UWORD wnsmall[4];             // small window sizes LTWH
  342.   char   *path;                 // variable search path
  343.   BOOL   usepath;               // 1=use path, 0=use global (forget it..)
  344.   struct Event *topbt;         // first of list of EVENTs
  345.   struct var *topvar;           // first of list of this gui's variables
  346.   struct guifile *next;         // next gui file
  347.   // ------------- private fields below
  348. };
  349.  
  350. /*********************************************************************
  351.     MAIN Gui4CLi STRUCTURE
  352.    !!! This is the structure you receive in the msg->gcmain field !!!
  353.    It's main use is to get a pointers to the top gui file (from where
  354.    you can see all events and all commands), or to the current lv
  355.    or to the Global variable list etc...
  356. **********************************************************************/
  357.  
  358. struct GCmain
  359. {  
  360.    LONG magic;                   // sanity check  (MM_G4C = 4848484)
  361.  
  362.    struct guifile *topguifile;   // first of a linked list of gui files
  363.    struct Event *curbt;          // current event pointer (for local vars etc)
  364.    struct Event *curgad;     // GAD - current gadget pointer (for info)
  365.    struct guifile *curgf;        // GUI - current gui pointer
  366.    struct fulist *curlv;         // LV  - current listview pointer
  367.    struct var *gtopvar;          // linked list of Global variables
  368.    struct imginfo *topimage;     // top of linked list of images
  369.  
  370.    LONG tab;                     // tabsize
  371.    char *pipebuff;               // pointer to pipe buffer
  372.    LONG grid;                    // grid size for visual edit def=1
  373.    LONG maxtransloop;            // set to 100 - how many times translate can retranslate the buffer before error
  374.    UBYTE  defscreenname[40];     // default screen name (* = front screen)
  375.  
  376.    // general purpose memory buffers (you can use them for temporary storage)
  377.    char *membuff[5];        // 5 main memory buffers of buffsize length
  378.    LONG buffsize;        // size of buffers
  379.  
  380.    // These are available for use.. (used internally as flags etc)
  381.    LONG num;                            // SPARE LONG
  382.    char buff[256];                      // SPARE BUFFER
  383.    char *pt, *pt2;                      // SPARE CHARACTER POINTERs
  384.    __aligned struct FileInfoBlock fib;  // SPARE fib
  385.    __aligned BPTR lk;                   // SPARE BPTR
  386.  
  387.    // for internal variables
  388.    LONG   src_pos;                      // position for searchvar
  389.    LONG   src_length;                   // var length for searchvar
  390.    USHORT red, green, blue;             // Last Palette's RGB values
  391.    LONG   color, totcolors;             // + color number + No of colors
  392.    struct imginfo *curimg;              // current image
  393.    LONG   mx, my;                       // mouse position
  394.  
  395.    // holding place for the default font (MONOspace)
  396.    struct TextAttr __aligned ta;        // our txtattr for the MONO font
  397.    UBYTE  fontbuff[40];                 // buffer for font name
  398.  
  399.    // ------------------ private fields below..
  400.  
  401. };
  402.  
  403. /*********************************************************************
  404.     Magic numbers
  405.     Some of these are used to check the "sanity" of    Gui4Cli, 
  406.     and others to identify where messages are comming from.
  407. **********************************************************************/
  408.  
  409. #define MM_PIPE_LAUNCH    6511841 // pipe launch identifier
  410. #define MM_PIPE_DATA    4523666 // pipe data identifier
  411. #define MM_PIPE_RDV     4526789    // magic for pipe rendez-vous struct
  412. #define MM_LAUNCH    7250838 // launch message identifier
  413. #define MM_GFILE    7225825    // gui file sanity check
  414. #define MM_C_GUI    7226625 // c:gui identifier
  415. #define MM_LISTVIEW     22108   // lv sanity check
  416. #define MM_G4C          4848484    // gcmain struct's sanity check
  417. #define MM_OUTSIDER     392001  // the g4cmsg message identifier
  418.  
  419.  
  420.  
  421.  
  422.